/* enum */
import AuthEnum from '@model/enum/AuthEnum.ts'
/* util */
import qs from '@src/util/querystring'
/* model */
import TaskStateEnum from '@model/enum/TaskStateEnum.ts'
/* util */
import { isArray } from '@src/util/type'
import AuthUtil from '@src/util/auth';
import { getRootWindow } from '@src/util/dom';
import { GrayFunctionEnum } from 'pub-bbx-global/pageType/dist/grayFunction'

export default {
  //是否开启客户解绑
  productCreateUnBindCustomer(){
    return this.initData?.productCreateUnBindCustomer
  },
  /* 权限 */
  auth() {
    return this.initData?.auth || [];
  },
  allowCreateTask() {
    return AuthUtil.hasAuth(this.auth, 'TASK_ADD')
  },
  /* 当前工单状态 */
  currentTaskState() {
    return this.isTaskCreate ? this.allotTask.state : this.task.state
  },
  /* 当前工单类型id */
  currentTaskTemplateId() {
    if (this.task.isDelete == 5) return this.task.templateId
    return this.isTaskCreate ? this.template.value : this.task.templateId
  },
  /* 禁用状态 */
  disabled() {
    return this.submitting || this.pending;
  },
  /* 编辑工单id */
  editId() {
    return this.workTask?.id || '';
  },
  /* 事件id 事件转工单用 */
  eventId() {
    return this.initData?.eventId || this.urlParams.eventId || '';
  },
  /** 
   * @description 是否是 复制工单
  */
  isCopyTask() {
    return this.initData?.fromCopy || window.location.href.indexOf('copyTask') > -1;
  },
  /**
   * @description 是否显示 [返回] 按钮 
   * 1. 工单编辑有工单id
   * 2. 
   * 3. 复制工单
   * 4. 事件转工单
  */
  isShowBackButton() {
    let path = this.path;
    return (
      (path.startsWith('/task/edit/') && path != '/task/edit')
        || path.startsWith('/task/noFilterEdit/')
        || path.startsWith('/task/copyTask')
        || path.startsWith('/event/convent2Task/jump')
        || (path.startsWith('/task/editV2/') && path !== '/task/editV2')
    )
  },
  /** 
   * @description 是否显示 [暂存] 按钮
   * 1. 是否开启工单草稿灰度
   * 2. 新建时有新建工单权限
   * 3. 编辑时有新建工单权限&inApprove==-1
  */
  isShowTemporarySaveButton() {
    const RootWindow = getRootWindow(window)
    if (!RootWindow.grayAuth?.taskCreateHalf) return false
    if (this.isTaskEdit) return this.auth?.TASK_ADD && this.workTask.inApprove == -1
    return this.auth?.TASK_ADD && !this.isFromProject
  },
  /** 
   * @description 是否显示 [保存] 按钮
   * 1. 当前工单状态不为空
   * 2. 且 当前工单状态 不等于 创建
  */
  isShowSaveButton() {
    return this.workTask.state && this.workTask.state != TaskStateEnum.CREATED.value;
  },
  /** 
   * @description 是否显示 [只保存] 按钮
   * 1. 当前工单状态 为空
   * 2. 且 当前工单状态 等于 创建
  */
  isShowOnlySaveButton() {
    return !this.workTask.state || this.workTask.state == TaskStateEnum.CREATED.value;
  },
  /** 
   * @description 是否显示 [保存并派单] 按钮
   * 1. 当前工单状态 为空
   * 2. 且 当前工单状态 等于 创建
   * 3. 有工单派单权限
  */
  isShowSaveAndAllotButton() {
    // 是否显示
    let show = false
    // 权限数据是否为数组
    let isAuthArray = isArray(this.auth)
    try {
      // 是否有权限
      let isHaveAuth = isAuthArray ? this.auth.indexOf(AuthEnum.TASK_DISPATCH) > -1 : Boolean(this.auth?.[AuthEnum.TASK_DISPATCH])
      show = this.isShowOnlySaveButton && isHaveAuth
    } catch (error) {
      show = false
      console.error('isShowSaveAndAllotButton ~ error', error)
    }

    // 新建状态，如果工单有高级审批，则不显示
    if(this.isTaskCreate && this.createNeedApprove) {
      return false
    }
    
    return show
  },
  /** 
  * @description 是否显示工单按钮组
  * 1. 不是新建计划任务
  * 2. 不是编辑计划任务
  * 3. 不是复制计划任务
  */
  isShowTaskButtonGroup() {
    return !this.isFromPlan && !this.isPlanTaskEdit && !this.isPlanTaskCopy;
  },
  /* 是否为 来自计划任务 */
  isFromPlan() {
    return this.initData?.fromPlan === true;
  },
  /* 是否为 来自客户新建 */
  isFromCustomer() {
    return this.initData?.fromCus === true;
  },
  /* 是否为 来自事件转工单 */
  isFromEvent() {
    return this.initData?.fromEve === true;
  },
  /* 是否为 来自产品新建 */
  isFromProduct() {
    return this.initData?.fromPro === true;
  },
  /* 是否为 编辑计划任务 */
  isPlanTaskEdit() {
    return this.initData?.editPlanTask === true;
  },

  /* 是否从 项目管理或者任务详情跳转过来的 */
  isFromProject() {
    return this.$route.query?.from === 'project'
  },

  /* 是否 项目管理或者当前任务的状态的是暂存状态 */
  isProjectTaskDraft() {
    return this.$route.query?.actionType === 'draft'
  },

  /* 是否 项目管理或者当前任务的状态的是新建状态 */
  isProjectTaskAdd() {
    return this.$route.query?.actionType === 'add'
  },

  /* 是否为 复制计划任务 */
  isPlanTaskCopy() {
    return this.initData?.copyPlanTask === true;
  },
  /* 是否为 新建 || 编辑 || 复制计划任务页面 */
  isPlanTaskPage() {
    const path = window.location.pathname
    return (path.indexOf('/task/planTask/create') > -1) || (path.indexOf('/task/planTask/edit') > -1) || (path.indexOf('/task/planTask/copy') > -1);
  },
  /* 是否为 工单创建 */
  isTaskCreate() {
    // isDelete==5说明还是草稿状态，不是一个真实工单
    return Boolean(this.workTask.id) === false || this.workTask.isDelete == 5;
  },
  /* 是否为 工单编辑 */
  isTaskEdit() {
    // 存在工单id并且isDelete不等于5
    return Boolean(this.workTask.id) === true && this.workTask.isDelete != 5;
  },
  path() {
    return this.initData?.path || '';
  },
  planTaskEditFormEl() {
    return this.$refs.planTaskEditForm;
  },
  urlParams() {
    return qs.parse(window.location.search);
  },
  state() {
    return {
      isCopyTask: this.isCopyTask,
      isFromPlan: this.isFromPlan,
      isFromEvent: this.isFromEvent,
      isTaskCreate: this.isTaskCreate,
      isTaskEdit: this.isTaskEdit,
      isPlanTaskEdit: this.isPlanTaskEdit,
      isPlanTaskCopy: this.isPlanTaskCopy,
      isFromCustomer: this.isFromCustomer,
      isFromProduct: this.isFromProduct,
      isDisabledTaskType: Object.keys(this.allotTask).length > 0
    }
  },
  task() {
    let task = null;
    let isTaskJson = typeof this.initData.task === 'string';
    
    try {
      task = (isTaskJson ? JSON.parse(this.initData?.task) : this.initData?.task) || {};
    } catch (error) {
      task = {};
      console.warn('taskEdit json.parse task -> error', error);
    }
    return task;
  },
  types() {
    return this.taskTypeObj?.writeList || this.initData?.taskTypeList || this.initData?.typeList || [];
  },
  workTask() {
    return this.initData?.workTask || this.initData?.task || {};
  },
  isAgendaTask(){
    return !!(this.planStartTime && this.planEndTime)
  },
  /** 
  * @description 是否显示备件清单
  * 1. 新建工单
  * 2. 不是计划任务
  * 3. 备件清单、服务项目、物料申领任意一个显示
  */
  showSparepartServiceList() {
    return ((this.isTaskCreate && !this.isPlanTaskPage) || this.task.isDelete == 5) && this.sparepartConfig.length;
  },
  isCanTaskPlanEdit() {
    return this.auth?.TASK_PLAN_EDIT
  },
  fieldNameMap() {
    return (
      this.fields.reduce((prev, current) => {
        prev[current.fieldName] = current;
        return prev;
      }, {})
    );
  },
  currentTaskTypeOptions() {
    const currentTaskType = this.types.filter(type => type.id === this.currentTaskTemplateId)[0]; 
    return currentTaskType?.options || {};
  },
  // 华大基因灰度
  isBgiSaas() {
    const RootWindow = getRootWindow(window)
    return Boolean(RootWindow.grayAuth?.bgiSaas)
  },
  // 自定义的附加组件展示
  customCardListFilter() {
    const currentTaskType = this.types.filter(type => type.id === this.currentTaskTemplateId)[0];
    return (currentTaskType?.cardSetting?.cardInfo || []).filter(x => !x.specialfrom && x.stateCanEdit && x.stateCanEdit.some(v => v === 'created'));
  },
  /** 当前登录用户 */
  loginUser() {
    return this.initData.loginUser || {};
  },
  /** 当前用户的权限 */
  permission() {
    return this.loginUser.authorities || {};
  },
  /**
   * 是否已归档
   */
  isArchive(){
    return this.task?.isDelete === 2;
  },
  /** 子组件所需的数据 */
  propsForSubComponents() {
    this.task.state = 'created';
    this.task.isAllowUpdate = true;

    return {
      task: this.task,
      auth: this.permission,
      isArchive:this.isArchive,

      receiptFields: [],
      linkman: {},
      address: {},
    }
  },
  isShowRightCard() {
    return this.showSparepartServiceList || this.customCardList.length;
  },
  // 工单节点拓展灰度
  taskFlowExtend() {
    const RootWindow = getRootWindow(window);
    return RootWindow?.grayAuth?.[GrayFunctionEnum.TaskFlowExtend] ?? false // 工单流程节点灰度
  },
  // 是否获取工单自定义接口（1.开启了taskFlowExtend灰度 2.编辑的状态）
  isTaskAllCustomNodeFields() {
    return this.taskFlowExtend && this.isTaskEdit
  },
  // 当前节点的id
  currentNodeId() {
    return this.task?.attribute?.currentNodeId
  }
}